package br.com.cpqd.ssar.mediador;

import br.com.cpqd.ssar.gerenciador.GerenciamentoArvore;
import br.com.cpqd.ssar.importadores.ControladorImportadores;
import br.com.cpqd.ssar.posprocessamento.TipoRelatorio;
import br.com.cpqd.ssar.utilitarias.Tijolo;
import br.com.cpqd.ssar.utilitarias.Cone;
import br.com.cpqd.ssar.utilitarias.Cilindro;
import br.com.cpqd.ssar.utilitarias.Geometria;
import br.com.cpqd.ssar.utilitarias.AtributosGeometria;
import br.com.cpqd.ssar.utilitarias.CopiarArquivo;
import br.com.cpqd.ssar.utilitarias.DominioComputacional;
import br.com.cpqd.ssar.utilitarias.ListaGeometrias;
import br.com.cpqd.ssar.utilitarias.Material;
import br.com.cpqd.ssar.utilitarias.Esfera;
import br.com.cpqd.ssar.utilitarias.ListaTipoRelatorio;
import br.com.cpqd.ssar.utilitarias.RelatorioPosProcessamento;
import br.com.cpqd.ssar.utilitarias.STL;
import br.com.cpqd.ssar.utilitarias.Triangulo;
import java.awt.Color;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Vector;
import java.io.BufferedWriter;
import java.io.File;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Controlador do Pacote que Gerencia o Armazenamento e RecuperaÃ§Ã£o de SimulaÃ§Ãµes
 * @author Carlos H. S. Santos
 * @version 1.0
 */
public class ControladorAbrirSalvar {

    private ControladorMateriais controladorMateriais;
    private ControladorDiretorios controladorDiretorios;
    private Vector list;
    private Vector listaRelatorios;
    private String filenameWrite;
    private String filenameWriteRelatorios;
    private String filenameRead;
    private String filenameReadRelatorios;
    private Geometria dominioComputacional;
    private Vector pml;
    /*
     * Construtor
     */

    public ControladorAbrirSalvar(ControladorMateriais controlar, ControladorDiretorios controlarDiretorio) {
        this.controladorMateriais = controlar;
        this.controladorDiretorios = controlarDiretorio;
        dominioComputacional = null;

    }

    /**
     * Definir os parametros para salvar a cena de simulaÃ§Ã£o
     * @param list Vector
     * @param  filenameWrite String
     */
    public void setParametrosSalvarProjeto(Vector tlist, Vector tlistRep, Geometria dominio, String tfilenameWrite, String tfilenameRelatorios) {
        list = tlist;
        listaRelatorios = tlistRep;
        filenameWrite = tfilenameWrite;
        filenameWriteRelatorios = tfilenameRelatorios;
        dominioComputacional = dominio;
    }

    /**
     * Controlador para salvar o relatorios de simulacao
     */
    public void salvarRelatorio() throws IOException {
        FileWriter is;                      // EspecificaÃ§Ã£o do arquivo de escrita
        BufferedWriter arquivoEscrever;     // Arquivo de escrita da simulaÃ§Ã£o
        String linha;                       // Linha a ser escrita no arquivo
        RelatorioPosProcessamento relatorio = new RelatorioPosProcessamento();
        Vector parametros = new Vector();

        /* Define o arquivo que serÃ¡ aberto para escrita */
        is = new FileWriter(filenameWriteRelatorios);
        /* abre o arquivo */
        arquivoEscrever = new BufferedWriter(is);

        if (listaRelatorios != null) {
            for (int cont = 0; cont < listaRelatorios.size(); cont++) {
                relatorio = (RelatorioPosProcessamento) listaRelatorios.get(cont);
                linha = (relatorio.getId() + "#:" + relatorio.getCampo() + "#:" + relatorio.getDirecao() + "#:");
                linha = (linha + relatorio.getIdTipoRelatorio() + "#:");
                linha = (linha + relatorio.getNomeTipoRelatorio() + "#:");
                linha = (linha + relatorio.getEnderecoBaseRelatorios());

                // Se relatorio == Movie2D
                if (relatorio.getIdTipoRelatorio() == 2) {
                    linha = (linha + "#:" + relatorio.getDirecaoOpcao());
                }

                // Inserindo os atributos do relatorio
                parametros = relatorio.getParametros();
                for (int j = 0; j < parametros.size(); j++) {
                    linha = (linha + "#:" + parametros.get(j).toString());
                }

                linha = (linha + "\n");
                try {
                    arquivoEscrever.write(linha);
                } catch (IOException ex) {
                    Logger.getLogger(ControladorAbrirSalvar.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
        arquivoEscrever.close();
        is.close();
    }

    /**
     * Abrir todos os relatorios de simulacao cadastrados no projeto
     * @return Vector ListaRelatorios
     */
    public Vector abrirRelatorios() throws IOException {
        Vector vetorRelatorios = new Vector();
        File file = new File(filenameReadRelatorios);   // Define o nome do arquivo da simulaÃ§Ã£o
        String linha = new String();
        RelatorioPosProcessamento relatorio;            // Relatorio
        ListaTipoRelatorio listaTipoRelatorios = new ListaTipoRelatorio();
        TipoRelatorio tipoRelatorio = new TipoRelatorio();
        BufferedReader arquivoLer;
        String[] splitLinha;
        // Atributos do relatorio (valores temporarios de controle de insercao)
        int id, valor;
        double did;
        Vector parametros = new Vector();

        try {
            arquivoLer = new BufferedReader(new FileReader(file));
            while ((linha = arquivoLer.readLine()) != null) {
                splitLinha = linha.split("#:");
                relatorio = new RelatorioPosProcessamento();
                relatorio.setId(Integer.parseInt(splitLinha[0]));
                relatorio.setCampo(splitLinha[1]);
                relatorio.setDirecao(splitLinha[2]);
                relatorio.setIdTipoRelatorio(Integer.parseInt(splitLinha[3]));
                relatorio.setNomeTipoRelatorio(splitLinha[4]);
                relatorio.setEnderecoBaseRelatorios(splitLinha[5]);

                // Se relatorio == Movie2D
                if (relatorio.getIdTipoRelatorio() == 2) {
                    relatorio.setDirecaoOpcao(splitLinha[6]);
                    double vvalor = Double.parseDouble(splitLinha[7]);
                    valor = (int) vvalor;
                    parametros.add(valor);
                    vvalor = Double.parseDouble(splitLinha[8]);
                    valor = (int) vvalor;
                    parametros.add(valor);

                } else {
                    id = relatorio.getIdTipoRelatorio();
                    tipoRelatorio = listaTipoRelatorios.getTipoRelatorio(id);
                    for (int cont = 6; cont < 6 + tipoRelatorio.getNparameters(); cont++) {
                        did = Double.valueOf(splitLinha[cont]);
                        valor = (int) did;
                        parametros.add(valor);
                    }
                }
                relatorio.setParametros(parametros);

                // ADicionando o relatorio da linha corrente no vetor de relatorios
                vetorRelatorios.add(relatorio);
            }
            arquivoLer.close();
        } catch (FileNotFoundException ex) {
            Logger.getLogger(ControladorAbrirSalvar.class.getName()).log(Level.SEVERE, null, ex);
        }


        return vetorRelatorios;
    }

    /**
     * Controlador para salvar o projeto de simulação atual
     */
    public void salvarProjeto() {

        ListaGeometrias listGeo;            // List of geometries
        FileWriter is;                      // EspecificaÃ§Ã£o do arquivo de escrita
        BufferedWriter arquivoEscrever;     // Arquivo de escrita da simulaÃ§Ã£o
        String linha;                       // Linha a ser escrita no arquivo
        String tipoGeometria;
        Geometria geometria;                // Geometrias inseridas em uma lista
        AtributosGeometria gAtt;            // Atributos das geometrias
        Material material;                  // Material dos objetos
        float[] referencia;                 // Coordenadas de referencia das geometrias
        Color color;                        // Cor definida para o objeto
         
         
           int i, j, idold = -1;                    // iteradores
        int idGeometriaAnterior = -1;
        boolean visible;                    // Verificar a visibilidades das geometrias
        float[] coordenadasIniciais = new float[3];
        float[] coordenadasFinais = new float[3];


        try {

            /* Define o arquivo que serÃ¡ aberto para escrita */
            is = new FileWriter(filenameWrite);


            /* abre o arquivo */
            arquivoEscrever = new BufferedWriter(is);

            String c1 = "// Cadastramento de Geometrias da SimulaÃ§Ã£o organizadas em Lista de Geometrias (L), (G) para\n";
            arquivoEscrever.write(c1);
            String c2 = "// as Geometrias e (D) para especificar as configuracoes do dominio computacional. Notar que o \n// primeiro caracter define essa especificaÃ§Ã£o\n";
            arquivoEscrever.write(c2);
            arquivoEscrever.write("//#:(D)#:Nome#:CoordXi#:CoordYi#:CoordZi#:CoordXf#:CoordYf#:coordzf#:IDMaterial#:Sx#:Sy#:Sz#:Escala\n");
            String c3 = "//#:(L)#:NomeLista#:Visivel#:Solido\n";
            arquivoEscrever.write(c3);
            String c4 = "//#:(G)#:ID#:TipoGeometria#:Nome#:IdMaterial#:IsRemovivel#:Red#:Green#:Blue#:X#:Y#:Z#:IsVisible#:IsSolid#:Parametros\n\n";
            arquivoEscrever.write(c4);

            // Armazena os dados do dominio computacional no arquivo de configuracao da simulacao
            if (dominioComputacional.getAtributos().getDiscretizacaoX() > 0) {
                coordenadasIniciais = dominioComputacional.getAtributos().getFirsPoint();
                coordenadasFinais = dominioComputacional.getAtributos().getSecondPoint();
                material = dominioComputacional.getMaterial();
                linha = ("D#:" + dominioComputacional.getNome() + "#:" + coordenadasIniciais[0] + "#:" + coordenadasIniciais[1] + "#:" + coordenadasIniciais[2] + "#:" + coordenadasFinais[0] + "#:" + coordenadasFinais[1] + "#:" + coordenadasFinais[2] + "#:" + material.getId() + "#:" + dominioComputacional.getAtributos().getDiscretizacaoX() + "#:" + dominioComputacional.getAtributos().getDiscretizacaoY() + "#:" + dominioComputacional.getAtributos().getDiscretizacaoZ() + "#:" + dominioComputacional.getAtributos().getEscala() + "#:" + dominioComputacional.getAtributos().getNSteps() + "\n");
                arquivoEscrever.write(linha);
            }

            /* for para o objeto 'nodeTree' que contem os grupos de objetos
             * e cada grupo de objeto contem uma lista de objetos do tipo Geometry
             */
            geometria = new Geometria();
            tipoGeometria = new String();
            for (i = 0; i < list.size(); i++) {
                listGeo = (ListaGeometrias) list.get(i);

                if (listGeo.getId() != idold) {
                    /* Inserindo as definiÃ§Ãµes da lista das geometrias */
                    linha = null;
                    linha = ("L#:" + listGeo.getId() + "#:" + listGeo.getName() + "#:" + listGeo.isVisible() + "#:" + listGeo.isSolid() + "\n");
                    arquivoEscrever.write(linha);
                    idold = listGeo.getId();
                    /* Insere as geometrias atreladas na lista acima armazenada */
                    for (j = 0; j < listGeo.getGeo().size(); j++) {
                        //material    = new Material();
                        //gAtt       = new AtributosGeometria();

                        System.out.println("CONT:: " + j + "  SIZE:: " + listGeo.getGeo().size());
                        geometria = (Geometria) listGeo.getGeo().get(j);
                        gAtt = geometria.getAtributos();
                        referencia = gAtt.getReferencial();
                        material = geometria.getMaterial();
                        color = material.getCor();
                        visible = geometria.isVisible();

                        /* Escreve as propriedades bÃ¡sicas da Geomtria */
                        linha = null;


                        if (gAtt instanceof Tijolo) {
                            tipoGeometria = "Tijolo";
                        } else if (gAtt instanceof Cilindro) {
                            tipoGeometria = "Cilindro";
                        } else if (gAtt instanceof Cone) {
                            tipoGeometria = "Cone";
                        } else if (gAtt instanceof Esfera) {
                            tipoGeometria = "Esfera";
                        } else if (gAtt instanceof STL) {
                            tipoGeometria = "STL";
                        } else {
                            System.out.println("Erro: Nenhum tipo de Geometria Selecionada.");
                            System.exit(0);
                        }

                        linha = ("G#:" + geometria.getIdentificador() + "#:" + tipoGeometria +
                                "#:" + geometria.getNome() +
                                "#:" + material.getId() +
                                "#:" + color.getRed() + "#:" + color.getGreen() + "#:" + color.getBlue() +
                                "#:" + referencia[0] +
                                "#:" + referencia[1] + "#:" + referencia[2] +
                                "#:" + geometria.isVisible() + "#:" + geometria.isSolid() + "#:");

                        /* Gravando um Tijolo */
                        if (gAtt instanceof Tijolo) {
                            Tijolo c = (Tijolo) geometria.getAtributos();
                            referencia = c.getFirsPoint();
                            linha = (linha + referencia[0] + "#:" + referencia[1] +
                                    "#:" + referencia[2] + "#:");
                            referencia = c.getSecondPoint();
                            linha = (linha + referencia[0] + "#:" + referencia[1] +
                                    "#:" + referencia[2]);
                        }

                        /* Gravando um Cilindro */
                        if (gAtt instanceof Cilindro) {
                            Cilindro c = (Cilindro) geometria.getAtributos();
                            linha = (linha + c.getRaio() + "#:" + c.getAltura());
                        }

                        /* Gravando um Cone */
                        if (gAtt instanceof Cone) {
                            Cone c = (Cone) geometria.getAtributos();
                            linha = (linha + c.getRaio() + "#:" + c.getAltura());
                        }

                        /* Gravando uma Esfera */
                        if (gAtt instanceof Esfera) {
                            Esfera c = (Esfera) geometria.getAtributos();
                            linha = (linha + c.getRaio());
                        }
                        if (gAtt instanceof STL) {
                            STL c = (STL) geometria.getAtributos();

                            // --- Copiando o arquivo STL do diretorio do Computador
                            // --- para o diretorio de Modelos do Projeto
                            // Verificar se o Sistema Operacional é Windows
                            Process process = null;

                            String osName = System.getProperty("os.name");
                            String nomeOrigem = new String(c.getCaminhoArquivo());
                            String nomeDestino = new String(controladorDiretorios.obterCaminhoDadosModelo() + File.separator + geometria.getNome() + ".stl");

                            float[] first = new float[3];
                            float[] second = new float[3];

                            // Armazenar os limites do STL
                            first = c.getFirsPoint();
                            linha = (linha + first[0] + "#:" + first[1] + "#:" + first[2]);
                            second = c.getSecondPoint();
                            linha = (linha + "#:" + second[0] + "#:" + second[1] + "#:" + second[2]);

                            // Armazenar a quantidade de elementos (Triangulos) que formam o STL
                            linha = (linha + "#:" + c.getNElements() + "#:");


                            //linha = (linha  + c.+ "#:");
                            // Chama a classe CopiarArquivo para salvar o STL dentro do projeto
                            if (CopiarArquivo.copiar(nomeOrigem, nomeDestino) == true) // Local onde o STL foi armazenado no projeto
                            {
                                linha = (linha + geometria.getNome() + ".stl");
                            }
                        }
                        linha = (linha + "\n");
                        try {
                            arquivoEscrever.write(linha);
                        } catch (IOException ex) {
                            Logger.getLogger(ControladorAbrirSalvar.class.getName()).log(Level.SEVERE, null, ex);
                        }
                    }
                }
            }
            arquivoEscrever.close();
            is.close();

        } catch (IOException ex) {
            Logger.getLogger(ControladorAbrirSalvar.class.getName()).log(Level.SEVERE, null, ex);
        }

    }

    /**
     * Atribui os parametros iniciais da simulaÃ§Ã£o para abrir um determinado projeto
     * @param filename String
     */
    public void setParameterosAbrirProjeto(String tfilename, String tfilenameReadRelatios, Vector pmlt) {
        this.pml = pmlt;
        filenameRead = tfilename;
        filenameReadRelatorios = tfilenameReadRelatios;
    }

    /**
     * Controlador da abertura de uma simulaÃ§Ã£o jÃ¡ armazenada em disco
     */
    public Vector abrirProjeto(ControladorImportadores controladorImportadores) {
        GerenciamentoArvore managementtree;
        ListaGeometrias listGeometry = new ListaGeometrias();   // Objeto principal que será retornado a cena de simulação
        Vector vectorGeometry = new Vector();                   // Armazena todas as geometrias contidas na cena de simulação
        File file = new File(filenameRead);                     // Define o nome do arquivo da simulaÃ§Ã£o
        String linha = new String();
        Geometria geometria;                                    // Geometrias inseridas em uma lista
        Material material;                                      // Material da Geometria
        AtributosGeometria gAtt;                                // Atributos das geometrias
        BufferedReader arquivoLer;
        float[] geoReference;
        float[] firstP;
        float[] secondP;
        Double[] geoColor = new Double[3];
        Color color;     
        int listIndex, indexOld, geoIndex, geoMaterial;
        boolean listVisible, listSolid, geoVisible, geoSolid;
        String[] splitLinha;        
        String listName, geoType, geoName;

        try {

            managementtree = new GerenciamentoArvore();
            arquivoLer = new BufferedReader(new FileReader(file));
            linha = arquivoLer.readLine();
            linha = arquivoLer.readLine();
            linha = arquivoLer.readLine();
            linha = arquivoLer.readLine();
            linha = arquivoLer.readLine();
            linha = arquivoLer.readLine();
            linha = arquivoLer.readLine();

            indexOld = -1;
            listIndex = 0;

            // datain.available() retorn 0 se o arquivo nÃ£o possuir mais linhas a serem lidas
            boolean inserir = false;
            geometria = new Geometria();
            while ((linha = arquivoLer.readLine()) != null) {

                // Identificador para a criaÃ§Ã£o da Lista de Geometrias
                inserir = false;

                if (linha.charAt(0) == 'L') {
                    splitLinha = linha.split("#:");

                    listIndex = Integer.parseInt(splitLinha[1]);
                    listVisible = Boolean.parseBoolean(splitLinha[3]);
                    listSolid = Boolean.parseBoolean(splitLinha[4]);
                    listGeometry = new ListaGeometrias(listIndex, splitLinha[2], listVisible, listSolid);
                    inserir = true;
                } // Identificar que define uma geometria
                else if (linha.charAt(0) == 'G') {
                    //geometry                = new Geometry();                    
                    Triangulo[] listTriangle = null;
                    geoReference = new float[3];
                    geoName = new String();
                    geoType = new String();
                    System.out.println("::: Linha:: " + linha);

                    splitLinha = linha.split("#:");
                    geoIndex = Integer.parseInt(splitLinha[1]);
                    geoType = splitLinha[2];
                    geoName = splitLinha[3];
                    geoMaterial = Integer.parseInt(splitLinha[4]);
                    if (geoMaterial == 0) {
                        geoMaterial++;
                    }
                    material = controladorMateriais.getMaterial(geoMaterial);

                    // Mensagem de erro relacionada a seleÃ§Ã£o de materiais e finalizaÃ§Ã£o imediata
                    if (material == null) {
                        System.out.println("Material não encontrado (" + geoMaterial + ") na lista de materiais disponÃ­veis");
                        System.exit(0);
                    }

                    geoColor[0] = Double.parseDouble(splitLinha[5]);
                    geoColor[1] = Double.parseDouble(splitLinha[6]);
                    geoColor[2] = Double.parseDouble(splitLinha[7]);
                    geoReference[0] = Float.parseFloat(splitLinha[8]);
                    geoReference[1] = Float.parseFloat(splitLinha[9]);
                    geoReference[2] = Float.parseFloat(splitLinha[10]);
                    geoVisible = Boolean.parseBoolean(splitLinha[11]);
                    geoSolid = Boolean.parseBoolean(splitLinha[12]);

                    if (geoType.equals("Tijolo")) {
                        firstP = new float[3];
                        secondP = new float[3];
                        firstP[0] = Float.parseFloat(splitLinha[13]);
                        firstP[1] = Float.parseFloat(splitLinha[14]);
                        firstP[2] = Float.parseFloat(splitLinha[15]);
                        secondP[0] = Float.parseFloat(splitLinha[16]);
                        secondP[0] = Float.parseFloat(splitLinha[17]);
                        secondP[0] = Float.parseFloat(splitLinha[18]);
                        geometria.setIdentificador(geoIndex);
                        geometria.setListaTriangulos(listTriangle);
                        geometria.setMaterial(material);
                        geometria = new Geometria(geoIndex, geoName, new Tijolo(firstP, secondP, geoReference, geoIndex),
                                geoVisible, geoSolid, material, 0.0f, 0.0f, 0.0f);

                    } else if (geoType.equals("Cone")) {
                        geometria = new Geometria(geoIndex, geoName,
                                new Cone(Float.parseFloat(splitLinha[14]), Float.parseFloat(splitLinha[13]), geoReference, geoIndex),
                                geoVisible, geoSolid, material, 0.0f, 0.0f, 0.0f);
                    } else if (geoType.equals("Cilindro")) {
                        geometria = new Geometria(geoIndex, geoName,
                                new Cilindro(Float.parseFloat(splitLinha[13]), Float.parseFloat(splitLinha[14]), geoReference, geoIndex),
                                geoVisible, geoSolid, material, 0.0f, 0.0f, 0.0f);
                    } else if (geoType.equals("Esfera")) {
                        geometria = new Geometria(geoIndex, geoName,
                                new Esfera(Float.parseFloat(splitLinha[13]), geoReference, geoIndex),
                                geoVisible, geoSolid, material, 0.0f, 0.0f, 0.0f);
                    } else if (geoType.equals("STL")) {
                        Geometria geo = new Geometria();
                        //System.out.println(":::: NOME:: " + controladorDiretorios.obterCaminhoDadosModelo());
                        String caminhoArquivo = new String(controladorDiretorios.obterCaminhoDadosModelo() + File.separator + geoName + ".stl");
                        geo = controladorImportadores.importarSTL(caminhoArquivo, geoIndex);

                        // Atributos Geometria
                        geo.setIdentificador(geoIndex);
                        geo.setNome(geoName);
                        geo.setSolid(geoSolid);
                        geo.setVisible(geoVisible);
                        geo.setMaterial(material);


                        // Abrindo os maximos e minimos do arquivo STL
                        float[] first = new float[3];
                        float[] second = new float[3];

                        first[0] = Float.parseFloat(splitLinha[13].toString());
                        first[1] = Float.parseFloat(splitLinha[14].toString());
                        first[2] = Float.parseFloat(splitLinha[15].toString());


                        second[0] = Float.parseFloat(splitLinha[16].toString());
                        second[1] = Float.parseFloat(splitLinha[17].toString());
                        second[2] = Float.parseFloat(splitLinha[18].toString());


                        // ALTERAR REFERENCIAS E TAMANHO
                        float tf = Float.parseFloat(splitLinha[19].toString());
                        int qtdElem = (int) tf;


                        geo.getAtributos().redimensionarSTL(first, second);
                        // Atribuindo a Geometria da Cena
                        geometria = new Geometria(geoIndex, geoName,
                                new STL(geo.getListaTriangulos(), caminhoArquivo, geoIndex, first, second, qtdElem),
                                geoVisible, geoSolid, material, 0.f, 0.f, 0.f);

                        //geometria.getAtributos().redimensionarSTL(first, second);
                        geometria.setListaTriangulos(geo.getListaTriangulos());

                        //geometria = geo;
                        System.out.println("NOME::::: " + geometria.getNome());
                        System.out.println("REF1: " + geoReference[0] + "  Ref2:: " + geoReference[1]);
                    } else {
                        System.out.println("Erro " + geoType + " : Nome errado.");
                        System.exit(0);
                    }
                    listGeometry.addGeometry(geometria);
                //inserir=false;
                } else if (linha.charAt(0) == 'D') {
                    splitLinha = linha.split("#:");
                    geoName = new String();
                    geoName = splitLinha[1];
                    firstP = new float[3];
                    secondP = new float[3];

                    firstP[0] = Float.parseFloat(splitLinha[2]);
                    firstP[1] = Float.parseFloat(splitLinha[3]);
                    firstP[2] = Float.parseFloat(splitLinha[4]);
                    secondP[0] = Float.parseFloat(splitLinha[5]);
                    secondP[1] = Float.parseFloat(splitLinha[6]);
                    secondP[2] = Float.parseFloat(splitLinha[7]);
                    geoMaterial = Integer.parseInt(splitLinha[8]);
                    int nsteps = Integer.parseInt(splitLinha[13]);

                    if (geoMaterial == 0) {
                        geoMaterial = 1;
                    }
                    material = controladorMateriais.getMaterial(geoMaterial);

                    int sx = Integer.valueOf(splitLinha[9]);
                    int sy = Integer.valueOf(splitLinha[10]);
                    int sz = Integer.valueOf(splitLinha[11]);
                    double escala = Double.valueOf(splitLinha[12]);

                    int pmlxi = Integer.valueOf(pml.get(0).toString());
                    int pmlyi = Integer.valueOf(pml.get(1).toString());
                    int pmlzi = Integer.valueOf(pml.get(2).toString());
                    int pmlxf = Integer.valueOf(pml.get(3).toString());
                    int pmlyf = Integer.valueOf(pml.get(4).toString());
                    int pmlzf = Integer.valueOf(pml.get(5).toString());
                    dominioComputacional = new Geometria(0, geoName, new DominioComputacional(firstP, secondP, firstP, 0, sx, sy, sz, pmlxi, pmlyi, pmlzi, pmlxf, pmlyf, pmlzf, "mm", nsteps), true, true, material, 0.0f, 0.0f, 0.0f);
                }

                if ((listIndex != indexOld) && (inserir == true)) {
                    indexOld = listIndex;
                    vectorGeometry.add(listGeometry);
                }
            } // Final do ELSE IF
            arquivoLer.close();
        } catch (IOException ex) {
            Logger.getLogger(ControladorAbrirSalvar.class.getName()).log(Level.SEVERE, null, ex);
        }
        return vectorGeometry;
    }

    /**
     * Retorna os parâmetros do dominio computacional armazenados no Modelos/scriptGeometrias.isar
     * @return dominio Dominio (Geometria)
     */
    public Geometria getDominioComputacional() {
        return dominioComputacional;
    }
}